home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 7: Programming / CDAT7.iso / Share / Codigo / hh / rsource.exe / Hexen Source / P_CEILNG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-22  |  7.2 KB  |  295 lines
  1.  
  2. //**************************************************************************
  3. //**
  4. //** p_ceilng.c : Heretic 2 : Raven Software, Corp.
  5. //**
  6. //** $RCSfile: p_ceilng.c,v $
  7. //** $Revision: 1.17 $
  8. //** $Date: 95/09/11 22:06:25 $
  9. //** $Author: cjr $
  10. //**
  11. //**************************************************************************
  12.  
  13. #include "h2def.h"
  14. #include "p_local.h"
  15. #include "soundst.h"
  16.  
  17. //==================================================================
  18. //==================================================================
  19. //
  20. //                                                      CEILINGS
  21. //
  22. //==================================================================
  23. //==================================================================
  24.  
  25. ceiling_t       *activeceilings[MAXCEILINGS];
  26.  
  27. //==================================================================
  28. //
  29. //      T_MoveCeiling
  30. //
  31. //==================================================================
  32. void T_MoveCeiling (ceiling_t *ceiling)
  33. {
  34.     result_e        res;
  35.  
  36.     switch(ceiling->direction)
  37.     {
  38. //        case 0:         // IN STASIS
  39. //            break;
  40.         case 1:         // UP
  41.             res = T_MovePlane(ceiling->sector,ceiling->speed,
  42.                     ceiling->topheight, false, 1, ceiling->direction);
  43.             if (res == RES_PASTDEST)
  44.             {
  45.                 SN_StopSequence((mobj_t *)&ceiling->sector->soundorg);
  46.                 switch(ceiling->type)
  47.                 {
  48.                     case CLEV_CRUSHANDRAISE:
  49.                         ceiling->direction = -1;
  50.                         ceiling->speed = ceiling->speed*2;
  51.                         break;
  52.                     default:
  53.                         P_RemoveActiveCeiling(ceiling);
  54.                         break;
  55.                 }
  56.             }
  57.             break;
  58.         case -1:        // DOWN
  59.             res = T_MovePlane(ceiling->sector,ceiling->speed,
  60.                 ceiling->bottomheight, ceiling->crush, 1, ceiling->direction);
  61.             if(res == RES_PASTDEST)
  62.             {
  63.                 SN_StopSequence((mobj_t *)&ceiling->sector->soundorg);
  64.                 switch(ceiling->type)
  65.                 {
  66.                     case CLEV_CRUSHANDRAISE:
  67.                     case CLEV_CRUSHRAISEANDSTAY:
  68.                         ceiling->direction = 1;
  69.                         ceiling->speed = ceiling->speed/2;
  70.                         break;
  71.                     default:
  72.                         P_RemoveActiveCeiling(ceiling);
  73.                         break;
  74.                 }
  75.             } 
  76.             else if(res == RES_CRUSHED)
  77.             {
  78.                 switch(ceiling->type)
  79.                 {
  80.                     case CLEV_CRUSHANDRAISE:
  81.                     case CLEV_LOWERANDCRUSH:
  82.                     case CLEV_CRUSHRAISEANDSTAY:
  83.                         //ceiling->speed = ceiling->speed/4;
  84.                         break;
  85.                     default:
  86.                         break;
  87.                 }
  88.             }
  89.             break;
  90.     }
  91. }
  92.  
  93. //==================================================================
  94. //
  95. //              EV_DoCeiling
  96. //              Move a ceiling up/down and all around!
  97. //
  98. //==================================================================
  99. int EV_DoCeiling (line_t *line, byte *arg, ceiling_e type)
  100. {
  101.     int                     secnum,rtn;
  102.     sector_t                *sec;
  103.     ceiling_t               *ceiling;
  104.  
  105.     secnum = -1;
  106.     rtn = 0;
  107.  
  108. /* Old Ceiling stasis code
  109.     //
  110.     //      Reactivate in-stasis ceilings...for certain types.
  111.     //
  112.     switch(type)
  113.     {
  114.         case CLEV_CRUSHANDRAISE:
  115.             P_ActivateInStasisCeiling(line);
  116.         default:
  117.             break;
  118.     }
  119. */
  120.     while ((secnum = P_FindSectorFromTag(arg[0], secnum)) >= 0)
  121.     {
  122.         sec = §ors[secnum];
  123.         if (sec->specialdata)
  124.             continue;
  125.  
  126.         //
  127.         // new door thinker
  128.         //
  129.         rtn = 1;
  130.         ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVSPEC, 0);
  131.         P_AddThinker (&ceiling->thinker);
  132.         sec->specialdata = ceiling;
  133.         ceiling->thinker.function = T_MoveCeiling;
  134.         ceiling->sector = sec;
  135.         ceiling->crush = 0;
  136.         ceiling->speed = arg[1]*(FRACUNIT/8);
  137.         switch(type)
  138.         {
  139.             case CLEV_CRUSHRAISEANDSTAY:
  140.                 ceiling->crush = arg[2]; // arg[2] = crushing value
  141.                 ceiling->topheight = sec->ceilingheight;
  142.                 ceiling->bottomheight = sec->floorheight + (8*FRACUNIT);
  143.                 ceiling->direction = -1;
  144.                 break;
  145.             case CLEV_CRUSHANDRAISE:
  146.                 ceiling->topheight = sec->ceilingheight;
  147.             case CLEV_LOWERANDCRUSH:
  148.                 ceiling->crush = arg[2]; // arg[2] = crushing value
  149.             case CLEV_LOWERTOFLOOR:
  150.                 ceiling->bottomheight = sec->floorheight;
  151.                 if(type != CLEV_LOWERTOFLOOR)
  152.                 {
  153.                     ceiling->bottomheight += 8*FRACUNIT;
  154.                 }
  155.                 ceiling->direction = -1;
  156.                 break;
  157.             case CLEV_RAISETOHIGHEST:
  158.                 ceiling->topheight = P_FindHighestCeilingSurrounding(sec);
  159.                 ceiling->direction = 1;
  160.                 break;
  161.             case CLEV_LOWERBYVALUE:
  162.                 ceiling->bottomheight = sec->ceilingheight-arg[2]*FRACUNIT;
  163.                 ceiling->direction = -1;
  164.                 break;
  165.             case CLEV_RAISEBYVALUE:
  166.                 ceiling->topheight = sec->ceilingheight+arg[2]*FRACUNIT;
  167.                 ceiling->direction = 1;
  168.                 break;
  169.             case CLEV_MOVETOVALUETIMES8:
  170.             {
  171.                 int destHeight = arg[2]*FRACUNIT*8;
  172.  
  173.                 if(arg[3])
  174.                 {
  175.                     destHeight = -destHeight;
  176.                 }
  177.                 if(sec->ceilingheight <= destHeight)
  178.                 {
  179.                     ceiling->direction = 1;
  180.                     ceiling->topheight = destHeight;
  181.                     if(sec->ceilingheight == destHeight)
  182.                     {
  183.                         rtn = 0;
  184.                     }
  185.                 }
  186.                 else if(sec->ceilingheight > destHeight)
  187.                 {
  188.                     ceiling->direction = -1;
  189.                     ceiling->bottomheight = destHeight;
  190.                 }
  191.                 break;
  192.             }
  193.             default:
  194.                 rtn = 0;
  195.                 break;
  196.         }
  197.         ceiling->tag = sec->tag;
  198.         ceiling->type = type;
  199.         P_AddActiveCeiling(ceiling);
  200.         if(rtn)
  201.         {
  202.             SN_StartSequence((mobj_t *)&ceiling->sector->soundorg, 
  203.                 SEQ_PLATFORM+ceiling->sector->seqType);
  204.         }
  205.     }
  206.     return rtn;
  207. }
  208.  
  209. //==================================================================
  210. //
  211. //              Add an active ceiling
  212. //
  213. //==================================================================
  214. void P_AddActiveCeiling(ceiling_t *c)
  215. {
  216.     int             i;
  217.     for (i = 0; i < MAXCEILINGS;i++)
  218.         if (activeceilings[i] == NULL)
  219.         {
  220.             activeceilings[i] = c;
  221.             return;
  222.         }
  223. }
  224.  
  225. //==================================================================
  226. //
  227. //              Remove a ceiling's thinker
  228. //
  229. //==================================================================
  230. void P_RemoveActiveCeiling(ceiling_t *c)
  231. {
  232.     int             i;
  233.  
  234.     for (i = 0;i < MAXCEILINGS;i++)
  235.         if (activeceilings[i] == c)
  236.         {
  237.             activeceilings[i]->sector->specialdata = NULL;
  238.             P_RemoveThinker (&activeceilings[i]->thinker);
  239.             P_TagFinished(activeceilings[i]->sector->tag);
  240.             activeceilings[i] = NULL;
  241.             break;
  242.         }
  243. }
  244.  
  245. #if 0
  246. //==================================================================
  247. //
  248. //              Restart a ceiling that's in-stasis
  249. //
  250. //==================================================================
  251. void P_ActivateInStasisCeiling(line_t *line)
  252. {
  253.     int     i;
  254.  
  255.     for (i = 0;i < MAXCEILINGS;i++)
  256.         if (activeceilings[i] && (activeceilings[i]->tag == line->arg1) &&
  257.             (activeceilings[i]->direction == 0))
  258.         {
  259.             activeceilings[i]->direction = activeceilings[i]->olddirection;
  260.             activeceilings[i]->thinker.function = T_MoveCeiling;
  261.             SN_StartSequence((mobj_t *)&activeceilings[i]->sector->soundorg,
  262.                 SEQ_PLATFORM+activeceilings[i]->sector->seqType);
  263.         }
  264. }
  265. #endif
  266.  
  267. //==================================================================
  268. //
  269. //              EV_CeilingCrushStop
  270. //              Stop a ceiling from crushing!
  271. //
  272. //==================================================================
  273.  
  274. int EV_CeilingCrushStop(line_t *line, byte *args)
  275. {
  276.     int             i;
  277.     int             rtn;
  278.  
  279.     rtn = 0;
  280.     for (i = 0;i < MAXCEILINGS;i++)
  281.     {
  282.         if(activeceilings[i] && activeceilings[i]->tag == args[0])        
  283.         {
  284.             rtn = 1;
  285.             SN_StopSequence((mobj_t*)&activeceilings[i]->sector->soundorg);
  286.             activeceilings[i]->sector->specialdata = NULL;
  287.             P_RemoveThinker (&activeceilings[i]->thinker);
  288.             P_TagFinished(activeceilings[i]->sector->tag);
  289.             activeceilings[i] = NULL;
  290.             break;
  291.         }
  292.     }
  293.     return rtn;
  294. }
  295.